#include <iostream>
#include <thread>
using namespace std;
//void myprint(const int & i,char * pmybuf)

void myprint(const int & i,string & pmybuf)
//void myprint(const int & i,char * pmybuf)
{
    cout<<i<<endl; // 实际上是 值传递，主线程detach子线程后，仍然安全
    
    cout<<pmybuf<<endl; // 指针实际上是 地址传递，主线程detach子线程后，会有问题
}
class SubThread
{
    public :
    int & m_i;
    SubThread(int & i):m_i(i) 
    {
        cout<<"构造函数"<<endl;
    }

    SubThread(const SubThread & sub):m_i(sub.m_i)
    {
        cout<<"拷贝构造函数"<<endl;
    }
    void operator() () // 不可以带参数
    {
        cout<<"sub2 thread start"<<endl;
        cout<<"m_i 值为:"<<m_i<<endl;
        cout<<"sub2 thread end"<<endl;
    }
    ~SubThread()
    {
        cout<<"destory"<<endl;
    }
    void thread_work(int num)
    {
        cout<<"子线程 thread work："<<num<<endl;
    }
};
int main()
{
    /*一: 传递 临时对象 作为线程参数
        1.1 要避免的陷阱 

        总结
        1.如果传递 int 这种简单类型，建议都是值传递，不要有引用
        2.如果传递类对象，避免隐式类型转换。全部都爱创建线程这一行构建出。在函数参数用引用来接
    
    */
    int myval = 1;
    int & ref= myval;
    char mybuf[] = "this is a test";
    /*
    thread mytobj(myprint,myval,mybuf); //事实上存在mybuf被主线程回收后 再利用mubuf转 string 的 可能性
    */
    cout<<"主线程id="<<std::this_thread::get_id()<<endl;
    // thread mytobj(myprint,myval,string(mybuf));
    // mytobj.join(); 
    cout<<"I Love China"<<endl;

    SubThread sub(myval);

    thread t3(&SubThread::thread_work,sub,15);
    t3.join();
    return 0;

    /*传递类对象，智能指针作为线程参数
    std::ref 
    */

}